﻿using System;
using System.Collections;
using System.Collections.Generic;
using NUnit.Framework;

namespace Xenta.Tests
{
    public static class Extensions
    {
        public static void AreEqualIgnoringCase(this string actual, string expected)
        {
            StringAssert.AreEqualIgnoringCase(expected, actual);
        }

        public static void AreNotEqualIgnoringCase(this string actual, string expected)
        {
            StringAssert.AreNotEqualIgnoringCase(expected, actual);
        }

        public static void Contains(this string actual, string expected)
        {
            StringAssert.Contains(expected, actual);
        }

        public static void DoesNotContain(this string actual, string expected)
        {
            StringAssert.DoesNotContain(expected, actual);
        }

        public static void DoesNotEndWith(this string actual, string expected)
        {
            StringAssert.DoesNotEndWith(expected, actual);
        }

        public static void DoesNotMatch(this string actual, string pattern)
        {
            StringAssert.DoesNotMatch(pattern, actual);
        }

        public static void DoesNotStartWith(this string actual, string expected)
        {
            StringAssert.DoesNotStartWith(expected, actual);
        }

        public static void EndsWith(this string actual, string expected)
        {
            StringAssert.EndsWith(expected, actual);
        }

        public static void IsMatch(this string actual, string pattern)
        {
            StringAssert.IsMatch(pattern, actual);
        }

        public static void StartsWith(this string actual, string expected)
        {
            StringAssert.StartsWith(expected, actual);
        }

        public static void AreEqual(this decimal actual, decimal expected)
        {
            Assert.AreEqual(expected, actual);
        }

        public static void AreEqual(this int actual, int expected)
        {
            Assert.AreEqual(expected, actual);
        }

        public static void AreEqual(this long actual, long expected)
        {
            Assert.AreEqual(expected, actual);
        }

        public static void AreEqual(this object actual, object expected)
        {
            Assert.AreEqual(expected, actual);
        }

        public static void AreEqual(this uint actual, uint expected)
        {
            Assert.AreEqual(expected, actual);
        }

        public static void AreEqual(this ulong actual, ulong expected)
        {
            Assert.AreEqual(expected, actual);
        }

        public static void AreEqual(this double actual, double expected, double delta)
        {
            Assert.AreEqual(expected, actual, delta);
        }

        public static void AreNotEqual(this decimal actual, decimal expected)
        {
            Assert.AreNotEqual(expected, actual);
        }

        public static void AreNotEqual(this double actual, double expected)
        {
            Assert.AreNotEqual(expected, actual);
        }

        public static void AreNotEqual(this float actual, float expected)
        {
            Assert.AreNotEqual(expected, actual);
        }

        public static void AreNotEqual(this int actual, int expected)
        {
            Assert.AreNotEqual(expected, actual);
        }

        public static void AreNotEqual(this long actual, long expected)
        {
            Assert.AreNotEqual(expected, actual);
        }

        public static void AreNotEqual(this object actual, object expected)
        {
            Assert.AreNotEqual(expected, actual);
        }

        public static void AreNotEqual(this uint actual, uint expected)
        {
            Assert.AreNotEqual(expected, actual);
        }

        public static void AreNotEqual(this ulong actual, ulong expected)
        {
            Assert.AreNotEqual(expected, actual);
        }

        public static void AreNotSame(this object actual, object expected)
        {
            Assert.AreNotSame(expected, actual);
        }

        public static void AreSame(this object actual, object expected)
        {
            Assert.AreSame(expected, actual);
        }

        public static void DoesContain<T>(this ICollection<T> actual, T expected)
        {
            Assert.True(actual.Contains(expected));
        }

        public static void DoesNotContain<T>(this ICollection<T> actual, T expected)
        {
            Assert.False(actual.Contains(expected));
        }

        public static void Greater(this decimal actual, decimal arg)
        {
            Assert.Greater(actual, arg);
        }

        public static void Greater(this double actual, double arg)
        {
            Assert.Greater(actual, arg);
        }

        public static void Greater(this float actual, float arg)
        {
            Assert.Greater(actual, arg);
        }

        public static void Greater(this IComparable actual, IComparable arg)
        {
            Assert.Greater(actual, arg);
        }

        public static void Greater(this int actual, int arg)
        {
            Assert.Greater(actual, arg);
        }

        public static void Greater(this long actual, long arg)
        {
            Assert.Greater(actual, arg);
        }

        public static void Greater(this uint actual, uint arg)
        {
            Assert.Greater(actual, arg);
        }

        public static void Greater(this ulong actual, ulong arg)
        {
            Assert.Greater(actual, arg);
        }

        public static void GreaterOrEqual(this decimal actual, decimal arg)
        {
            Assert.GreaterOrEqual(actual, arg);
        }

        public static void GreaterOrEqual(this double actual, double arg)
        {
            Assert.GreaterOrEqual(actual, arg);
        }

        public static void GreaterOrEqual(this float actual, float arg)
        {
            Assert.GreaterOrEqual(actual, arg);
        }

        public static void GreaterOrEqual(this IComparable actual, IComparable arg)
        {
            Assert.GreaterOrEqual(actual, arg);
        }

        public static void GreaterOrEqual(this int actual, int arg)
        {
            Assert.GreaterOrEqual(actual, arg);
        }

        public static void GreaterOrEqual(this long actual, long arg)
        {
            Assert.GreaterOrEqual(actual, arg);
        }

        public static void GreaterOrEqual(this uint actual, uint arg)
        {
            Assert.GreaterOrEqual(actual, arg);
        }

        public static void GreaterOrEqual(this ulong actual, ulong arg)
        {
            Assert.GreaterOrEqual(actual, arg);
        }

        public static void IsEmpty(this IEnumerable actual)
        {
            Assert.IsEmpty(actual);
        }

        public static void IsEmpty(this string actual)
        {
            Assert.IsEmpty(actual);
        }

        public static void IsFalse(this bool actual)
        {
            Assert.IsFalse(actual);
        }

        public static void IsNaN(this double actual)
        {
            Assert.IsNaN(actual);
        }

        public static void IsNotEmpty(this IEnumerable actual)
        {
            Assert.IsNotEmpty(actual);
        }

        public static void IsNotEmpty(this string actual)
        {
            Assert.IsNotEmpty(actual);
        }

        public static void IsNotNull(this object actual)
        {
            Assert.IsNotNull(actual);
        }

        public static void IsNotNullOrEmpty(this string actual)
        {
            Assert.IsNotNullOrEmpty(actual);
        }

        public static void IsNull(this object actual)
        {
            Assert.IsNull(actual);
        }

        public static void IsNullOrEmpty(this string actual)
        {
            Assert.IsNullOrEmpty(actual);
        }

        public static void IsTrue(this bool actual)
        {
            Assert.IsTrue(actual);
        }

        public static void Less(this decimal actual, decimal arg)
        {
            Assert.Less(actual, arg);
        }

        public static void Less(this double actual, double arg)
        {
            Assert.Less(actual, arg);
        }

        public static void Less(this float actual, float arg)
        {
            Assert.Less(actual, arg);
        }

        public static void Less(this IComparable actual, IComparable arg)
        {
            Assert.Less(actual, arg);
        }

        public static void Less(this int actual, int arg)
        {
            Assert.Less(actual, arg);
        }

        public static void Less(this long actual, long arg)
        {
            Assert.Less(actual, arg);
        }

        public static void Less(this uint actual, uint arg)
        {
            Assert.Less(actual, arg);
        }

        public static void Less(this ulong actual, ulong arg)
        {
            Assert.Less(actual, arg);
        }

        public static void LessOrEqual(this decimal actual, decimal arg)
        {
            Assert.LessOrEqual(actual, arg);
        }

        public static void LessOrEqual(this double actual, double arg)
        {
            Assert.LessOrEqual(actual, arg);
        }

        public static void LessOrEqual(this float actual, float arg)
        {
            Assert.LessOrEqual(actual, arg);
        }

        public static void LessOrEqual(this IComparable actual, IComparable arg)
        {
            Assert.LessOrEqual(actual, arg);
        }

        public static void LessOrEqual(this int actual, int arg)
        {
            Assert.LessOrEqual(actual, arg);
        }

        public static void LessOrEqual(this long actual, long arg)
        {
            Assert.LessOrEqual(actual, arg);
        }

        public static void LessOrEqual(this uint actual, uint arg)
        {
            Assert.LessOrEqual(actual, arg);
        }

        public static void LessOrEqual(this ulong actual, ulong arg)
        {
            Assert.LessOrEqual(actual, arg);
        }
    }
}
